home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 319_02 / str.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-16  |  3.0 KB  |  204 lines
  1. /*
  2.     CPP V5 -- string handling routines.
  3.  
  4.     source: str.c
  5.     started: October 6, 1985
  6.     version: May 26, 1988; July 21, 1988
  7.  
  8.     Written by Edward K. Ream.
  9.     This software is in the public domain.
  10.  
  11.     See the read.me file for disclaimer and other information.
  12. */
  13.  
  14. #include "cpp.h"
  15.  
  16. /*
  17.     Allocate memory big enough to hold the string,
  18.     then copy the string to the allocated memory.
  19. */
  20. char *
  21. str_alloc(s)
  22. register char *s;
  23. {
  24.     register char * p;
  25.     register int n;
  26.  
  27.     TRACEPB("str_alloc", printf("(%s)\n", pr_str(s)));
  28.  
  29.     n = str_len(s) + 1;
  30.     p = m_alloc(n);
  31.     str_cpy(p, s);
  32.  
  33.     RETURN_PTR("str_alloc", p);
  34. }
  35.  
  36. /*
  37.     Concatenate s2 to the end of s1.
  38. */
  39.  
  40. void
  41. str_cat(s1, s2)
  42. register char *s1;
  43. register char *s2;
  44. {
  45.  
  46. #ifdef SHERLOCK
  47.     char *old_s1=s1;
  48.     char *old_s2=s2;
  49. #endif
  50.  
  51.     TRACEP("str_cat", printf("(%p, %s)", s1, s2));
  52.  
  53.     while(*s1++) {
  54.         ;
  55.     }
  56.     s1--;
  57.     while(*s2) {
  58.         *s1++ = *s2++;
  59.     }
  60.     *s1 = '\0';
  61.  
  62.     TRACE("str_cpy", printf(" strlen(s1=old_s1+s2): %d=%d+%d\n",
  63.         str_len(old_s1), strlen(old_s1)-strlen(old_s2), strlen(old_s2)));
  64. }
  65.  
  66. /*
  67.     Allocate global memory for two strings
  68.     This is NOT the same as strcat()!!
  69. */
  70. char *
  71. str_mcat(s1, s2)
  72. register char *s1;
  73. register char *s2;
  74. {
  75.     register char * p;
  76.     register int n1, n2;
  77.  
  78.     TRACEP("str_mcat", printf("(%s, %s)\n", s1, s2));
  79.  
  80.     n1 = str_len(s1);
  81.     n2 = str_len(s2);
  82.     p = m_alloc(n1 + n2 + 1);
  83.     str_cpy(p, s1);
  84.     str_cpy(p + n1, s2);
  85.  
  86.     TRACEPN("str_mcat", printf("returns <%s>\n", p));
  87.     return p;
  88. }
  89.  
  90. /*
  91.     Compare s1 and s2.
  92.     Return <0  ==0  >0
  93. */
  94.  
  95. int
  96. str_cmp(s1, s2)
  97. register char *s1;
  98. register char *s2;
  99. {
  100.     TRACEP("str_cmp", printf("(%s, %s)\n", s1, s2));
  101.  
  102.     while (*s1 == *s2) {
  103.         if (*s1 == '\0') {
  104.             return 0;
  105.         }
  106.         else {
  107.             s1++;
  108.             s2++;
  109.         }
  110.     }
  111.     return ((int)*s1) - ((int)*s2);
  112. }
  113.  
  114. /*
  115.     Copy s2 to s1.
  116.     s1 must be large enough to hold s2.
  117. */
  118. void
  119. str_cpy(s1, s2)
  120. register char *s1;
  121. register char *s2;
  122. {
  123.  
  124. #ifdef SHERLOCK
  125.     char * old_s1=s1;
  126. #endif
  127.  
  128.     TRACEP("str_cpy", printf("(%p, %s)", s1, s2));
  129.  
  130.     while (*s2) {
  131.         *s1++ = *s2++;
  132.     }
  133.     *s1 = '\0';
  134.  
  135.     TRACE("str_cpy", printf(" strlen(s1): %d\n", strlen(old_s1)));
  136. }
  137.  
  138. /*
  139.     Return TRUE if s1 == s2
  140. */
  141. bool
  142. str_eq(s1, s2)
  143. register char *s1;
  144. register char *s2;
  145. {
  146.     TRACEP("str_eq", printf("(%s, %s)\n", s1, s2));
  147.  
  148.     while(*s1) {
  149.         if (*s1++ != *s2++) {
  150.             TRACEP("str_eq", printf("returns FALSE\n"));
  151.             return FALSE;
  152.         }
  153.     }
  154.     TRACEPN("str_eq",
  155.         printf("returns %s\n", (!*s2) ? "TRUE" : "FALSE"));
  156.     return !*s2;
  157. }
  158.  
  159. /*
  160.     Return the length of a string.
  161. */
  162. int
  163. str_len(s)
  164. register char *s;
  165. {
  166.     register int len;
  167.  
  168.     TRACEP("str_len", printf("(%s)\n", s));
  169.  
  170.     len=0;
  171.     while (*s++) {
  172.         len++;
  173.     }
  174.  
  175.     TRACEPN("str_len", printf("returns %d\n", len));
  176.     return len;
  177. }
  178.  
  179. /*
  180.     Convert a string to lower case.
  181. */
  182. void
  183. str_lower(s)
  184. register char *s;
  185. {
  186.     while (*s) {
  187.         *s = tolower(*s);
  188.         s++;
  189.     }
  190. }
  191.  
  192. /*
  193.     Convert a string to upper case.
  194. */
  195. void
  196. str_upper(s)
  197. register char *s;
  198. {
  199.     while (*s) {
  200.         *s = toupper(*s);
  201.         s++;
  202.     }
  203. }
  204.